/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package Logica.Controladoras.Movimientos;

import Logica.Controladoras.ControladoraLogica;
import Logica.Core.MateriaPrima.MateriaPrima;
import Logica.Core.Movimientos.Bascula;
import Logica.Core.Movimientos.LibroEntradas;
import Logica.Core.Movimientos.LibroSalidas;
import Logica.Core.Movimientos.Movimiento;
import Logica.Core.Producto.Producto;
import Logica.Core.Vehiculo.Rodado;
import Persistencia.ControladoraPersistencia;
import Persistencia.JPAControllers.exceptions.NonexistentEntityException;
import Persistencia.JPAControllers.exceptions.PreexistingEntityException;
import java.util.Date;
import java.util.LinkedList;
import java.util.List;

/**
 *
 * @author Luciano
 */
public final class ControladoraLogicaMovimiento {

    protected ControladoraPersistencia miControladora;
    protected ControladoraLogica miLogica;
    private List<Bascula> misBasculas = new LinkedList<>();
    private List<LibroEntradas> misLibrosEntradas = new LinkedList<>();
    private List<LibroSalidas> misLibrosSalidas = new LinkedList<>();

    public ControladoraLogicaMovimiento(ControladoraPersistencia miControladora, ControladoraLogica miLogica) {
        this.miControladora = miControladora;
        this.miLogica = miLogica;

        misBasculas = dameMisBasculas();
        misLibrosEntradas = dameMiLibroEntradas();
        misLibrosSalidas = dameMisLibrosSalidas();
    }

    // <editor-fold defaultstate="collapsed" desc="Clase Bascula">
    public void crearBascula(double pesoBruto, double tara, Movimiento miMovimiento) throws PreexistingEntityException, Exception {

        misBasculas = dameMisBasculas();
        int id = misBasculas.size();
        boolean encontro = false;
        Bascula miNuevoBascula = new Bascula(id, pesoBruto, tara, miMovimiento);


        for (int i = 0; i < misBasculas.size() && !encontro; i++) {
            Bascula miBascula = misBasculas.get(i);
            if (miBascula.getId() == id) {
                encontro = true;
                throw new PreexistingEntityException("Bascula ya Existente.");
            }
        }

        misBasculas.add(miNuevoBascula);
        miControladora.getMiPersistenciaBascula().crearBascula(miNuevoBascula);
    }

    public void eliminarBascula(int id) throws NonexistentEntityException, Exception {
        misBasculas = dameMisBasculas();
        boolean encontro = false;
        Bascula miBascula = null;

        for (int i = 0; i < misBasculas.size() && !encontro; i++) {
            miBascula = misBasculas.get(i);
            if (miBascula.getId() == id) {
                encontro = true;
                misBasculas.remove(i);
            }
        }

        miControladora.getMiPersistenciaBascula().eliminarBascula(id);
    }

    public void modificarBascula(int id, double pesoBruto, double tara, Movimiento miMovimiento) throws NonexistentEntityException, Exception {
        misBasculas = dameMisBasculas();
        int pos = 0;
        boolean encuenetraBascula = false, encontro = false;
        Bascula miBascula = null;

        for (int i = 0; i < misBasculas.size() && !encuenetraBascula; i++) {
            miBascula = misBasculas.get(i);
            if (miBascula.getMiMovimiento() == miMovimiento) {
                pos = i;
                encuenetraBascula = true;
            }
        }

        for (int i = 0; i < misBasculas.size(); i++) {
            Bascula cliente = misBasculas.get(i);
            if (miBascula.getId() == id) {
                encontro = true;
            }
        }

        if (encontro) {
            throw new Exception("Bascula ya Existente.");
        } else {
            miBascula.setPesoBruto(pesoBruto);
            miBascula.setTara(tara);

            misBasculas.set(pos, miBascula);
            miControladora.getMiPersistenciaBascula().modificarBascula(miBascula);
        }
    }

    public Bascula dameUnBascula(int id) {
        misBasculas = dameMisBasculas();
        boolean encontro = false;
        Bascula miBascula = null;

        for (int i = 0; i < misBasculas.size() && !encontro; i++) {
            miBascula = misBasculas.get(i);
            if (miBascula.getId() == id) {
                encontro = true;
            }
        }

        return miBascula;
    }

    public List<Bascula> dameMisBasculas() {
        misBasculas = miControladora.getMiPersistenciaBascula().dameMisBascula();
        return misBasculas;
    }
    // </editor-fold>

    // <editor-fold defaultstate="collapsed" desc="Clase LibroEntradas">
    public void crearLibroEntradas(Bascula miBascula, MateriaPrima miMateriaPrima, Date fecha, Date hora, Rodado miRodado) throws PreexistingEntityException, Exception {

        misLibrosEntradas = dameMiLibroEntradas();
        int id = misLibrosEntradas.size();
        boolean encontro = false;
        LibroEntradas miNuevoLibroEntradas = new LibroEntradas(id, miBascula, miMateriaPrima, fecha, hora, miRodado);


        for (int i = 0; i < misLibrosEntradas.size() && !encontro; i++) {
            LibroEntradas miLibrosEntradas = misLibrosEntradas.get(i);
            if (miLibrosEntradas.getFecha().equals(fecha) && miLibrosEntradas.getHora().equals(hora)) {
                encontro = true;
                throw new PreexistingEntityException("LibroEntradas ya Existente.");
            }
        }

        misLibrosEntradas.add(miNuevoLibroEntradas);
        miControladora.getMiPersistenciaLibroEntradas().crearLibroEntradas(miNuevoLibroEntradas);
    }

    public void eliminarLibroEntradas(int id, Date fecha, Date hora) throws NonexistentEntityException, Exception {
        misLibrosEntradas = dameMiLibroEntradas();
        boolean encontro = false;
        LibroEntradas miLibrosEntradas = null;

        for (int i = 0; i < misLibrosEntradas.size() && !encontro; i++) {
            miLibrosEntradas = misLibrosEntradas.get(i);
            if (miLibrosEntradas.getFecha().equals(fecha) && miLibrosEntradas.getHora().equals(hora)) {
                encontro = true;
                misLibrosEntradas.remove(i);
            }
        }

        miControladora.getMiPersistenciaLibroEntradas().eliminarLibroEntradas(id);
    }

    public void modificarLibroEntradas(Bascula miBascula, MateriaPrima miMateriaPrima, Date fecha, Date hora, Rodado miRodado) throws NonexistentEntityException, Exception {
        misLibrosEntradas = dameMiLibroEntradas();
        boolean encontro = false;
        int pos = 0;
        LibroEntradas miLibrosEntradas = null;

        for (int i = 0; i < misLibrosEntradas.size() && !encontro; i++) {
            miLibrosEntradas = misLibrosEntradas.get(i);

            if (miLibrosEntradas.getFecha().equals(fecha) && miLibrosEntradas.getHora().equals(hora)) {
                encontro = true;
                pos = i;
            }

        }


        miLibrosEntradas.setMiBascula(miBascula);
        miLibrosEntradas.setMiMateriaPrima(miMateriaPrima);
        miLibrosEntradas.setMiRodado(miRodado);

        misLibrosEntradas.set(pos, miLibrosEntradas);
        miControladora.getMiPersistenciaLibroEntradas().modificarLibroEntradas(miLibrosEntradas);

    }

    public LibroEntradas dameUnLibroEntradas(Date fecha, Date hora) {
        misLibrosEntradas = dameMiLibroEntradas();
        boolean encontro = false;
        LibroEntradas miLibrosEntradas = null;

        for (int i = 0; i < misLibrosEntradas.size() && !encontro; i++) {
            miLibrosEntradas = misLibrosEntradas.get(i);
            if (miLibrosEntradas.getFecha().equals(fecha) && miLibrosEntradas.getHora().equals(hora)) {
                encontro = true;
            }
        }

        return miLibrosEntradas;
    }

    public List<LibroEntradas> dameMiLibroEntradas() {
        misLibrosEntradas = miControladora.getMiPersistenciaLibroEntradas().dameMisLibroEntradas();
        return misLibrosEntradas;
    }
    // </editor-fold>

    // <editor-fold defaultstate="collapsed" desc="Clase LibroSalidas">
    public void crearLibroSalidas(String destino, List<Producto> misProductos, Date fecha, Date hora, Rodado miRodado) throws PreexistingEntityException, Exception {

        misLibrosSalidas = dameMisLibrosSalidas();
        int id = misLibrosSalidas.size();
        boolean encontro = false;
        LibroSalidas miNuevoLibroSalidas = new LibroSalidas(id, destino, misProductos, fecha, hora, miRodado);


        for (int i = 0; i < misLibrosSalidas.size() && !encontro; i++) {
            LibroSalidas miLibrosSalidas = misLibrosSalidas.get(i);
            if (miLibrosSalidas.getFecha().equals(fecha) && miLibrosSalidas.getHora().equals(hora)) {
                encontro = true;
                throw new PreexistingEntityException("LibroSalidas ya Existente.");
            }
        }

        //  *** Se debe eliminar de los Depósitos la Lista de Productos que esta saliendo.....    ***

        misLibrosSalidas.add(miNuevoLibroSalidas);
        miControladora.getMiPersistenciaLibroSalidas().crearLibroSalidas(miNuevoLibroSalidas);
    }

    public void eliminarLibroSalidas(int id, Date fecha, Date hora) throws NonexistentEntityException, Exception {
        misLibrosSalidas = dameMisLibrosSalidas();
        boolean encontro = false;
        LibroSalidas miLibrosSalidas = null;

        for (int i = 0; i < misLibrosSalidas.size() && !encontro; i++) {
            miLibrosSalidas = misLibrosSalidas.get(i);
            if (miLibrosSalidas.getFecha().equals(fecha) && miLibrosSalidas.getHora().equals(hora)) {
                encontro = true;
                misLibrosSalidas.remove(i);
            }
        }

        miControladora.getMiPersistenciaLibroSalidas().eliminarLibroSalidas(id);
    }

    public void modificarLibroSalidas(String destino, Date fecha, Date hora, Rodado miRodado) throws NonexistentEntityException, Exception {
        misLibrosSalidas = dameMisLibrosSalidas();
        boolean encontro = false;
        int pos = 0;
        LibroSalidas miLibrosSalidas = null;

        for (int i = 0; i < misLibrosSalidas.size() && !encontro; i++) {
            miLibrosSalidas = misLibrosSalidas.get(i);

            if (miLibrosSalidas.getFecha().equals(fecha) && miLibrosSalidas.getHora().equals(hora)) {
                encontro = true;
                pos = i;
            }

        }


        miLibrosSalidas.setDestino(destino);
        miLibrosSalidas.setMiRodado(miRodado);

        misLibrosSalidas.set(pos, miLibrosSalidas);
        miControladora.getMiPersistenciaLibroSalidas().modificarLibroSalidas(miLibrosSalidas);

    }

    public LibroSalidas dameUnLibroSalidas(Date fecha, Date hora) {
        misLibrosSalidas = dameMisLibrosSalidas();
        boolean encontro = false;
        LibroSalidas miLibrosSalidas = null;

        for (int i = 0; i < misLibrosSalidas.size() && !encontro; i++) {
            miLibrosSalidas = misLibrosSalidas.get(i);
            if (miLibrosSalidas.getFecha().equals(fecha) && miLibrosSalidas.getHora().equals(hora)) {
                encontro = true;
            }
        }

        return miLibrosSalidas;
    }

    public List<LibroSalidas> dameMisLibrosSalidas() {
        misLibrosSalidas = miControladora.getMiPersistenciaLibroSalidas().dameMisLibroSalidas();
        return misLibrosSalidas;
    }
    // </editor-fold>
}
